///*
// * Copyright 2002-2011 the original author or authors.
// *
// * Licensed under the Apache License, Version 2.0 (the "License");
// * you may not use this file except in compliance with the License.
// * You may obtain a copy of the License at
// *
// *      http://www.apache.org/licenses/LICENSE-2.0
// *
// * Unless required by applicable law or agreed to in writing, software
// * distributed under the License is distributed on an "AS IS" BASIS,
// * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// * See the License for the specific language governing permissions and
// * limitations under the License.
// */
//
//package com.asset.salesforce.jacksonConvertor;
//
//import java.io.IOException;
//import java.nio.charset.Charset;
//import java.util.List;
//
//import org.springframework.http.HttpInputMessage;
//import org.springframework.http.HttpOutputMessage;
//import org.springframework.http.MediaType;
//import org.springframework.http.converter.AbstractHttpMessageConverter;
//import org.springframework.http.converter.HttpMessageNotReadableException;
//import org.springframework.http.converter.HttpMessageNotWritableException;
//import org.springframework.util.Assert;
//
//import com.fasterxml.jackson.core.JsonEncoding;
//import com.fasterxml.jackson.core.JsonGenerator;
//import com.fasterxml.jackson.core.JsonProcessingException;
//import com.fasterxml.jackson.databind.JavaType;
//import com.fasterxml.jackson.databind.ObjectMapper;
//import com.fasterxml.jackson.databind.type.TypeFactory;
//
///**
// * Implementation of {@link org.springframework.http.converter.HttpMessageConverter HttpMessageConverter}
// * that can read and write JSON using <a href="http://jackson.codehaus.org/">Jackson's</a> {@link ObjectMapper}.
// *
// * <p>This converter can be used to bind to typed beans, or untyped {@link java.util.HashMap HashMap} instances.
// *
// * <p>By default, this converter supports {@code application/json}. This can be overridden by setting the
// * {@link #setSupportedMediaTypes(List) supportedMediaTypes} property.
// *
// * @author Arjen Poutsma
// * @since 3.0
// * @see org.springframework.web.servlet.view.json.MappingJacksonJsonView
// */
//public class MappingJackson2HttpMessageConverter extends AbstractHttpMessageConverter<Object> {
//
//	public static final Charset DEFAULT_CHARSET = Charset.forName("UTF-8");
//
//
//	private ObjectMapper objectMapper = new ObjectMapper();
//
//	private boolean prefixJson = false;
//
//
//	/**
//	 * Construct a new {@code BindingJacksonHttpMessageConverter}.
//	 */
//	public MappingJackson2HttpMessageConverter() {
//		super(new MediaType("application", "json", DEFAULT_CHARSET));
//	}
//
//	/**
//	 * Set the {@code ObjectMapper} for this view. If not set, a default
//	 * {@link ObjectMapper#ObjectMapper() ObjectMapper} is used.
//	 * <p>Setting a custom-configured {@code ObjectMapper} is one way to take further control of the JSON
//	 * serialization process. For example, an extended {@link org.codehaus.jackson.map.SerializerFactory}
//	 * can be configured that provides custom serializers for specific types. The other option for refining
//	 * the serialization process is to use Jackson's provided annotations on the types to be serialized,
//	 * in which case a custom-configured ObjectMapper is unnecessary.
//	 */
//	public void setObjectMapper(ObjectMapper objectMapper) {
//		Assert.notNull(objectMapper, "ObjectMapper must not be null");
//		this.objectMapper = objectMapper;
//	}
//
//	/**
//	 * Return the underlying {@code ObjectMapper} for this view.
//	 */
//	public ObjectMapper getObjectMapper() {
//		return this.objectMapper;
//	}
//
//	/**
//	 * Indicate whether the JSON output by this view should be prefixed with "{} &&". Default is false.
//	 * <p>Prefixing the JSON string in this manner is used to help prevent JSON Hijacking.
//	 * The prefix renders the string syntactically invalid as a script so that it cannot be hijacked.
//	 * This prefix does not affect the evaluation of JSON, but if JSON validation is performed on the
//	 * string, the prefix would need to be ignored.
//	 */
//	public void setPrefixJson(boolean prefixJson) {
//		this.prefixJson = prefixJson;
//	}
//
//
//	@Override
//	public boolean canRead(Class<?> clazz, MediaType mediaType) {
//		JavaType javaType = getJavaType(clazz);
//		return (this.objectMapper.canDeserialize(javaType) && canRead(mediaType));
//	}
//
//	@Override
//	public boolean canWrite(Class<?> clazz, MediaType mediaType) {
//		return (this.objectMapper.canSerialize(clazz) && canWrite(mediaType));
//	}
//
//	@Override
//	protected boolean supports(Class<?> clazz) {
//		// should not be called, since we override canRead/Write instead
//		throw new UnsupportedOperationException();
//	}
//
//	@Override
//	protected Object readInternal(Class<?> clazz, HttpInputMessage inputMessage)
//			throws IOException, HttpMessageNotReadableException {
//
//		JavaType javaType = getJavaType(clazz);
//		try {
//			return this.objectMapper.readValue(inputMessage.getBody(), javaType);
//		}
//		catch (JsonProcessingException ex) {
//			throw new HttpMessageNotReadableException("Could not read JSON: " + ex.getMessage(), ex);
//		}
//	}
//
//	@Override
//	protected void writeInternal(Object object, HttpOutputMessage outputMessage)
//			throws IOException, HttpMessageNotWritableException {
//
//		JsonEncoding encoding = getJsonEncoding(outputMessage.getHeaders().getContentType());
//		JsonGenerator jsonGenerator =
//				this.objectMapper.getJsonFactory().createJsonGenerator(outputMessage.getBody(), encoding);
//		try {
//			if (this.prefixJson) {
//				jsonGenerator.writeRaw("{} && ");
//			}
//			this.objectMapper.writeValue(jsonGenerator, object);
//		}
//		catch (JsonProcessingException ex) {
//			throw new HttpMessageNotWritableException("Could not write JSON: " + ex.getMessage(), ex);
//		}
//	}
//
//
//	/**
//	 * Return the Jackson {@link JavaType} for the specified class.
//	 * <p>The default implementation returns {@link TypeFactory#type(java.lang.reflect.Type)},
//	 * but this can be overridden in subclasses, to allow for custom generic collection handling.
//	 * For instance:
//	 * <pre class="code">
//	 * protected JavaType getJavaType(Class&lt;?&gt; clazz) {
//	 *   if (List.class.isAssignableFrom(clazz)) {
//	 *     return TypeFactory.collectionType(ArrayList.class, MyBean.class);
//	 *   } else {
//	 *     return super.getJavaType(clazz);
//	 *   }
//	 * }
//	 * </pre>
//	 * @param clazz the class to return the java type for
//	 * @return the java type
//	 */
//	protected JavaType getJavaType(Class<?> clazz) {
//		return TypeFactory.defaultInstance().constructType(clazz);
//	}
//
//	/**
//	 * Determine the JSON encoding to use for the given content type.
//	 * @param contentType the media type as requested by the caller
//	 * @return the JSON encoding to use (never <code>null</code>)
//	 */
//	protected JsonEncoding getJsonEncoding(MediaType contentType) {
//		if (contentType != null && contentType.getCharSet() != null) {
//			Charset charset = contentType.getCharSet();
//			for (JsonEncoding encoding : JsonEncoding.values()) {
//				if (charset.name().equals(encoding.getJavaName())) {
//					return encoding;
//				}
//			}
//		}
//		return JsonEncoding.UTF8;
//	}
//
//}
